home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / program / pxbud.zip / PDXTBLGE.CPP < prev    next >
C/C++ Source or Header  |  1991-05-17  |  9KB  |  304 lines
  1. /*┌───────────────────────────────────────────────────────────────────────┐
  2.   │                                                                       │
  3.   │   Module:  PDXTBLGE.CPP                                               │
  4.   │   Author:  Rick Kligman                                               │
  5.   │   Purpose: Source code for Paradox Table Generic Class                │
  6.   │                                                                       │
  7.   │   Last Modified: 05-17-91 00:34am                                     │
  8.   │                                                                       │
  9.   │   Copyright 1991 Rick Kligman                                         │
  10.   │   This code may be freely used and distributed in commercial apps     │
  11.   │   provided some mention of PXBuddy++ is made in the documentation.    │
  12.   │                                                                       │
  13.   │   Version 1.00                                                        │
  14.   └───────────────────────────────────────────────────────────────────────┘ */
  15.  
  16. #include "pdxtblge.h"
  17.  
  18. //    ╓───────────────────────────────────────────────────────────────╖
  19. //    ║              Constructor for GenericTbl class                 ║
  20. //    ╚═══════════════════════════════════════════════════════════════╝
  21.  
  22. GenericTbl::GenericTbl()
  23. {
  24. }
  25.  
  26. //    ╓───────────────────────────────────────────────────────────────╖
  27. //    ║               Destructor for GenericTbl class                 ║
  28. //    ╚═══════════════════════════════════════════════════════════════╝
  29.  
  30. GenericTbl::~GenericTbl()
  31. {
  32. }
  33.  
  34.  
  35. //    ╓───────────────────────────────────────────────────────────────╖
  36. //    ║                   Search for CHAR value                       ║
  37. //    ╚═══════════════════════════════════════════════════════════════╝
  38.  
  39. int GenericTbl::search(char *fld, char *srchvar, int mode)
  40. {
  41.   FIELDHANDLE   fh;
  42.   int           err;
  43.  
  44.   err = PXFldHandle(th, fld, &fh);
  45.   CKERR;
  46.  
  47.   err = PXPutAlpha(rh, fh, srchvar);
  48.   CKERR;
  49.  
  50.   err = search_fld(fh, mode);
  51.  
  52.   return (err);       // if no error then PXSUCCESS will be returned
  53. }
  54.  
  55.  
  56. //    ╓───────────────────────────────────────────────────────────────╖
  57. //    ║                   Actually Search Field                       ║
  58. //    ╚═══════════════════════════════════════════════════════════════╝
  59.  
  60. int GenericTbl::search_fld(FIELDHANDLE fh, int mode)
  61. {
  62.   int   err;
  63.  
  64.   //  extra if on CLOSESTRECORD is done because even if it finds something
  65.   //  it will return RECNOTFOUND since it is an inexact match
  66.  
  67.   err = PXSrchFld(th, rh, fh, mode);
  68.   if (mode == CLOSESTRECORD && err == PXERR_RECNOTFOUND)
  69.       err = PXSUCCESS;
  70.  
  71.   return (err);       // if no error then PXSUCCESS will be returned
  72. }
  73.  
  74. //    ╓──────────────────────────────────────────────────────────────╖
  75. //    ║               Test a char field to see if its blank          ║
  76. //    ╚══════════════════════════════════════════════════════════════╝
  77.  
  78. int GenericTbl::getfld(FIELDHANDLE fh, int fldlen, char *field)
  79. {
  80.   int   blank;
  81.   int   err;
  82.  
  83.   err = PXFldBlank(rh, fh, &blank);
  84.   CKERR;
  85.  
  86.   if (blank)                          // char field was blank
  87.       field [0] = NULL;
  88.   else
  89.       if ((err = PXGetAlpha(rh, fh, fldlen, field)) != 0)
  90.           if (err == PXERR_BUFTOOSMALL)
  91.               err = PXSUCCESS;
  92.  
  93.  
  94.   return err;     // will be PXSUCCESS if everything went OK
  95. }
  96.  
  97. //    ╓──────────────────────────────────────────────────────────────╖
  98. //    ║            Test a short field to see if its blank            ║
  99. //    ╚══════════════════════════════════════════════════════════════╝
  100.  
  101. int GenericTbl::getfld(FIELDHANDLE fh, short &field)
  102. {
  103.   int   blank;
  104.   int   err;
  105.  
  106.   err = PXFldBlank(rh, fh, &blank);
  107.   CKERR;
  108.  
  109.   if (blank)                          // short was blank
  110.       field = 0;
  111.   else
  112.       err = PXGetShort(rh, fh, &field);
  113.  
  114.   return err;     // will be PXSUCCESS if everything went OK
  115. }
  116.  
  117. //    ╓──────────────────────────────────────────────────────────────╖
  118. //    ║            Test a double field to see if its blank           ║
  119. //    ╚══════════════════════════════════════════════════════════════╝
  120.  
  121. int GenericTbl::getfld(FIELDHANDLE fh, double &field)
  122. {
  123.   int   blank;
  124.   int   err;
  125.  
  126.   err = PXFldBlank(rh, fh, &blank);
  127.   CKERR;
  128.  
  129.   if (blank)                          // double was blank
  130.       field = 0;
  131.   else
  132.       err = PXGetDoub(rh, fh, &field);
  133.  
  134.   return err;     // will be PXSUCCESS if everything went OK
  135. }
  136.  
  137.  
  138. //    ╓──────────────────────────────────────────────────────────────╖
  139. //    ║            Test a date field to see if its blank             ║
  140. //    ╚══════════════════════════════════════════════════════════════╝
  141.  
  142. int GenericTbl::getfld(FIELDHANDLE fh, char *field)
  143. {
  144.   int   blank;
  145.   int   err;
  146.   long  date;
  147.  
  148.   err = PXFldBlank(rh, fh, &blank);
  149.   CKERR;
  150.  
  151.   if (blank)                          // date was blank
  152.       field [0] = NULL;
  153.   else {
  154.     err = PXGetDate(rh, fh, &date);
  155.     CKERR;
  156.     date_decode(field, date);
  157.   }
  158.  
  159.   return err;     // will be PXSUCCESS if everything went OK
  160. }
  161.  
  162. //    ╓──────────────────────────────────────────────────────────────╖
  163. //    ║               Test a char field to see if its blank          ║
  164. //    ╚══════════════════════════════════════════════════════════════╝
  165.  
  166. int GenericTbl::putfld(FIELDHANDLE fh, char *field)
  167. {
  168.   int   err;
  169.  
  170.   err = PXPutAlpha(rh, fh, field);
  171.  
  172.   return err;     // will be PXSUCCESS if everything went OK
  173. }
  174.  
  175. //    ╓──────────────────────────────────────────────────────────────╖
  176. //    ║            Test a short field to see if its blank            ║
  177. //    ╚══════════════════════════════════════════════════════════════╝
  178.  
  179. int GenericTbl::putfld(FIELDHANDLE fh, short &field)
  180. {
  181.   int   err;
  182.  
  183.   if ( field == 0 && (! blanks_as_zeros) )
  184.       err = PXPutBlank(rh, fh);
  185.   else
  186.       err = PXPutShort(rh, fh, field);
  187.  
  188.   return err;     // will be PXSUCCESS if everything went OK
  189. }
  190.  
  191. //    ╓──────────────────────────────────────────────────────────────╖
  192. //    ║            Test a double field to see if its blank           ║
  193. //    ╚══════════════════════════════════════════════════════════════╝
  194.  
  195. int GenericTbl::putfld(FIELDHANDLE fh, double &field)
  196. {
  197.   int   err;
  198.  
  199.   if ( field == 0 && (! blanks_as_zeros) )
  200.       err = PXPutBlank(rh, fh);
  201.   else
  202.       err = PXPutDoub(rh, fh, field);
  203.  
  204.   return err;     // will be PXSUCCESS if everything went OK
  205. }
  206.  
  207.  
  208. //    ╓──────────────────────────────────────────────────────────────╖
  209. //    ║            Test a date field to see if its blank             ║
  210. //    ╚══════════════════════════════════════════════════════════════╝
  211.  
  212. int GenericTbl::putfld(FIELDHANDLE fh, char *field, int)
  213. {
  214.   int   err;
  215.  
  216.   //  if the date is blank it can be one of two things. If the user never
  217.   //  enters the field then it will be NULL. If the user does go through
  218.   //  the field and leaves it blank, Vermont converts the date to 00/00/00
  219.  
  220.   if ( (field [0] == NULL || (field [0] == '0' && field [1] == '0')) &&
  221.         (! blanks_as_zeros) )
  222.           err = PXPutBlank(rh, fh);
  223.   else
  224.           err = date_encode(rh, fh, field);
  225.  
  226.   return err;     // will be PXSUCCESS if everything went OK
  227. }
  228.  
  229. //    ╓──────────────────────────────────────────────────────────────╖
  230. //    ║                 Make a Date into a string                    ║
  231. //    ╚══════════════════════════════════════════════════════════════╝
  232.  
  233. void GenericTbl::date_decode(char *newdate, long date)
  234. {
  235.   int         month, day, year;
  236.   char        mm [3], dd [3], yy [5], inter [3];
  237.   char        s [12];
  238.  
  239.   PXDateDecode(date, &month, &day, &year);
  240.  
  241.   itoa(month, mm, 10);        // here we want to format the date
  242.   itoa(day, dd, 10);          // so that it appears as 05/03/90
  243.   itoa(year, yy, 10);
  244.  
  245.   inter [2] = NULL;           // only need to NULL once
  246.  
  247.   if (strlen(mm) == 1) {
  248.     inter [0] = '0';
  249.     inter [1] = mm [0];
  250.     strcpy(mm, inter);
  251.   }
  252.  
  253.   if (strlen(dd) == 1) {
  254.     inter [0] = '0';
  255.     inter [1] = dd [0];
  256.     strcpy(dd, inter);
  257.   }
  258.  
  259.   inter [0] = yy [2];
  260.   inter [1] = yy [3];
  261.   strcpy(yy, inter);
  262.  
  263.   strcpy(s, mm);
  264.   strcat(s, "/");
  265.   strcat(s, dd);
  266.   strcat(s, "/");
  267.   strcat(s, yy);
  268.  
  269.   strcpy(newdate, s);
  270. }
  271.  
  272. //    ╓──────────────────────────────────────────────────────────────╖
  273. //    ║                 Make a String into a Date                    ║
  274. //    ╚══════════════════════════════════════════════════════════════╝
  275.  
  276. int GenericTbl::date_encode(RECORDHANDLE rh, FIELDHANDLE fh, char *olddate)
  277. {
  278.   long        date;
  279.   int         month, day, year;
  280.   int         err;
  281.   char        inter [3];
  282.  
  283.   inter [0] = olddate [0];
  284.   inter [1] = olddate [1];
  285.   inter [2] = NULL;
  286.   month = atoi(inter);
  287.  
  288.   inter [0] = olddate [3];
  289.   inter [1] = olddate [4];
  290.   day = atoi(inter);
  291.  
  292.   inter [0] = olddate [6];
  293.   inter [1] = olddate [7];
  294.   year = atoi(inter);
  295.  
  296.   err = PXDateEncode(month, day, year, &date);
  297.   CKERR;
  298.  
  299.   err = PXPutDate(rh, fh, date);
  300.  
  301.   return err;
  302. }
  303.  
  304.